package com.sicheng.蓝桥.练习题.线段树;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;

/**
 * @author zsc
 * @version 1.0
 * @date 2022/5/4 22:22
 */
public class 区间最大公约数 {
    /**
     * 给定一个长度为 N 的数列  A ，以及 M 条指令，每条指令可能是以下两种之一：
     * <p>
     * C l r d，表示把 A[l],A[l+1],…,A[r] 都加上 d。
     * Q l r，表示询问 A[l],A[l+1],…,A[r] 的最大公约数(GCD)。
     * 对于每个询问，输出一个整数表示答案。
     * <p>
     * 输入格式
     * 第一行两个整数 N,M。
     * <p>
     * 第二行 N 个整数 A[i]。
     * <p>
     * 接下来 M 行表示 M 条指令，每条指令的格式如题目描述所示。
     * <p>
     * 输出格式
     * 对于每个询问，输出一个整数表示答案。
     * <p>
     * 每个答案占一行。
     * <p>
     * 数据范围
     * N≤500000,M≤100000,
     * 1≤A[i]≤1018,
     * |d|≤1018
     * 输入样例：
     * 5 5
     * 1 3 5 7 9
     * Q 1 5
     * C 1 5 1
     * Q 1 5
     * C 3 3 6
     * Q 2 4
     * 输出样例：
     * 1
     * 2
     * 4
     */

    static BufferedReader read = new BufferedReader(new InputStreamReader(System.in));
    static BufferedWriter log = new BufferedWriter(new OutputStreamWriter(System.out));
    static Node[] tree;
    static long[] w;
    static int n, m;

    public static void main(String[] args) throws Exception {
        String[] ss = read.readLine().split(" ");
        n = Integer.parseInt(ss[0]);
        m = Integer.parseInt(ss[1]);
        w = new long[n + 1];
        tree = new Node[n * 4];
        ss = read.readLine().split(" ");
        for (int i = 1; i <= n; i++) {
            w[i] = Long.parseLong(ss[i - 1]);
        }
        build(1, 1, n);
        while (m-- > 0) {
            ss = read.readLine().split(" ");
            int a = Integer.parseInt(ss[1]), b = Integer.parseInt(ss[2]);

            switch (ss[0]) {
                case "Q":
                    long left = query(1, 1, a).sum, right = query(1, a + 1, b).gcd;
                    log.write(Math.abs(gcd(left, right)) + "\n");
                    break;
                case "C":
                    long c = Long.parseLong(ss[3]);
                    modify(1, a, c);
                    if (b + 1 <= n)
                        modify(1, b + 1, -c);
                    break;
            }
        }
        log.flush();
    }

    public static void build(int u, int l, int r) {
        if (l == r) {
            tree[u] = new Node(l, r, w[l] - w[l - 1], w[l] - w[l - 1]);
        } else {
            tree[u] = new Node(l, r);
            int mid = tree[u].l + tree[u].r >> 1;
            build(u << 1, l, mid);
            build(u << 1 | 1, mid + 1, r);
            pushUp(u);
        }
    }


    public static Node query(int u, int l, int r) {
        if (tree[u].l >= l && tree[u].r <= r)
            return tree[u];

        long mid = tree[u].l + tree[u].r >> 1;
        if (r <= mid)
            return query(u << 1, l, r);
        else if (l > mid)
            return query(u << 1 | 1, l, r);
        else {
            Node left = query(u << 1, l, r);
            Node right = query(u << 1 | 1, l, r);
            Node res = new Node(l, r);
            pushUp(res, left, right);
            return res;
        }

    }

    public static void modify(int u, int x, long c) {
        if (tree[u].l == x && tree[u].r == x) {
            tree[u].sum += c;
            tree[u].gcd += c;
        } else {
            long mid = tree[u].l + tree[u].r >> 1;
            if (x <= mid)
                modify(u << 1, x, c);
            else
                modify(u << 1 | 1, x, c);
            pushUp(u);
        }
    }


    public static void pushUp(int u) {
        pushUp(tree[u], tree[u << 1], tree[u << 1 | 1]);
    }

    public static void pushUp(Node u, Node l, Node r) {
        u.sum = l.sum + r.sum;
        u.gcd = gcd(l.gcd, r.gcd);
    }

    public static long gcd(long a, long b) {
        return b == 0 ? a : gcd(b, a % b);
    }


    static class Node {
        int l, r;
        long sum;
        long gcd;

        Node(int l, int r) {
            this.l = l;
            this.r = r;
        }

        Node(int l, int r, long sum, long gcd) {
            this.l = l;
            this.r = r;
            this.sum = sum;
            this.gcd = gcd;
        }
    }

}
